home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / RTVBE210.ZIP / PMPRO.H < prev    next >
C/C++ Source or Header  |  1996-02-05  |  8KB  |  211 lines
  1. /****************************************************************************
  2. *
  3. *                                PM/Pro Library
  4. *
  5. *                    Copyright (C) 1996 SciTech Software.
  6. *                            All rights reserved.
  7. *
  8. * Filename:        $Workfile:   pmpro.h  $
  9. * Version:        $Revision:   1.0  $
  10. *
  11. * Language:        ANSI C
  12. * Environment:    Real mode and 16/32 bit Protected Mode under MSDOS
  13. *
  14. * Description:    Header file for the DOS extender independant protected
  15. *                mode programming library. This library will need to be
  16. *                included in all programs that use SciTech Software's
  17. *                products that are to be compiled in protected mode.
  18. *
  19. *                This Professional version of the library also provides
  20. *                simplified interrupt handling, allowing all common interrupt
  21. *                handlers to be hooked and handled directly with normal C
  22. *                functions, both in 16 bit and 32 bit modes. Note however that
  23. *                simplified handling does not mean slow performance! All low
  24. *                level interrupt handling is done efficiently in assembler
  25. *                for speed (well actually necessary to insulate the
  26. *                application from the lack of far pointers in 32 bit PM). The
  27. *                interrupt handlers currently supported are:
  28. *
  29. *                    Mouse (0x33 callback)
  30. *                   Timer Tick (0x8)
  31. *                    Keyboard (0x9 and 0x15)
  32. *                    Control C/Break (0x23/0x1B)
  33. *                    Critical Error (0x24)
  34. *
  35. * $Date:   05 Feb 1996 21:44:32  $ $Author:   KendallB  $
  36. *
  37. ****************************************************************************/
  38.  
  39. #ifndef    __PMPRO_H
  40. #define    __PMPRO_H
  41.  
  42. #ifndef    __PMODE_H
  43. #include "pmode.h"
  44. #endif
  45.  
  46. /*--------------------------- Macros and Typedefs -------------------------*/
  47.  
  48. /* Define the different types of interrupt handlers that we support        */
  49.  
  50. typedef uint (PMAPI *PM_criticalHandler)(uint axValue,uint diValue);
  51. typedef void (PMAPI *PM_breakHandler)(uint breakHit);
  52. typedef void (PMAPI *PM_intHandler)(void);
  53. typedef short (PMAPI *PM_key15Handler)(short scanCode);
  54. typedef void (PMAPI *PM_mouseHandler)(uint event, uint butstate,
  55.     uint x,uint y,uint mickeyX,uint mickeyY);
  56.  
  57. /* Create a type for representing far pointers in both 16 and 32 bit
  58.  * protected mode.
  59.  */
  60.  
  61. #ifdef    PM386
  62. typedef    struct {
  63.     long    off;
  64.     short    sel;
  65.     } PMFARPTR;
  66. #define    PMNULL    {0,0}
  67. #else
  68. typedef    void *PMFARPTR;
  69. #define    PMNULL    NULL
  70. #endif
  71.  
  72. /*--------------------------- Function Prototypes -------------------------*/
  73.  
  74. #ifdef    __cplusplus
  75. extern "C" {            /* Use "C" linkage when in C++ mode    */
  76. #endif
  77.  
  78. /* Routine to install a mouse interrupt handling routine. The
  79.  * mouse handler routine is a normal C function, and the PM library
  80.  * will take care of passing the correct parameters to the function,
  81.  * and switching to a local stack.
  82.  *
  83.  * Note that you _must_ lock the memory containing the mouse interrupt
  84.  * handler with the PM_lockPages() function otherwise you may encounter
  85.  * problems in virtual memory environments.
  86.  */
  87.  
  88. int     PMAPI PM_setMouseHandler(int mask,PM_mouseHandler mh);
  89. void     PMAPI PM_restoreMouseHandler(void);
  90.  
  91. /* Routine to reset the mouse driver, and re-install the current
  92.  * mouse interrupt handler if one was currently installed (since the
  93.  * mouse reset will automatically remove this handler.
  94.  */
  95.  
  96. void     PMAPI PM_resetMouseDriver(int hardReset);
  97.  
  98. /* Routines to install and remove timer and keyboard interrupt handlers.
  99.  * The handler routines are normal C functions. If the return value from
  100.  * the function is PM_chainInt, the previous handler will be chained
  101.  * to, otherwise the interrupt will simply return.
  102.  *
  103.  * Note that you _must_ lock the memory containing the interrupt
  104.  * handlers with the PM_lockPages() function otherwise you may encounter
  105.  * problems in virtual memory environments.
  106.  */
  107.  
  108. void     PMAPI PM_setTimerHandler(PM_intHandler ih);
  109. void     PMAPI PM_chainPrevTimer(void);
  110. void     PMAPI PM_restoreTimerHandler(void);
  111. void     PMAPI PM_setKeyHandler(PM_intHandler ih);
  112. void     PMAPI PM_chainPrevKey(void);
  113. void     PMAPI PM_restoreKeyHandler(void);
  114.  
  115. /* Routines to hook and unhook the alternate Int 15h keyboard intercept
  116.  * callout routine. Your event handler will need to return the following:
  117.  *
  118.  *    scanCode     - Let the BIOS process scan code (chains to previous handler)
  119.  *    0             - You have processed the scan code so flush from BIOS
  120.  *
  121.  * Note that this is not available under all DOS extenders, but does
  122.  * work under real mode, DOS4GW and X32-VM. It does not work under the
  123.  * PowerPack 32 bit DOS extenders. If you figure out how to do it let us know!
  124.  */
  125.  
  126. void     PMAPI PM_setKey15Handler(PM_key15Handler ih);
  127. void     PMAPI PM_restoreKey15Handler(void);
  128.  
  129. /* Routines to install and remove the control c/break interrupt handlers.
  130.  * Interrupt handling is performed by the PM/Pro library, and you can call
  131.  * the supplied routines to test the status of the Ctrl-C and Ctrl-Break
  132.  * flags. If you pass the value TRUE for 'clearFlag' to these routines,
  133.  * the internal flags will be reset in order to catch another Ctrl-C or
  134.  * Ctrl-Break interrupt.
  135.  */
  136.  
  137. void     PMAPI PM_installBreakHandler(void);
  138. int     PMAPI PM_ctrlCHit(int clearFlag);
  139. int        PMAPI PM_ctrlBreakHit(int clearFlag);
  140. void     PMAPI PM_restoreBreakHandler(void);
  141.  
  142. /* Routine to install an alternate break handler that will call your
  143.  * code directly. This is not available under all DOS extenders, but does
  144.  * work under real mode, DOS4GW and X32-VM. It does not work under the
  145.  * PowerPack 32 bit DOS extenders. If you figure out how to do it let us know!
  146.  *
  147.  * Note that you should either install one or the other, but not both!
  148.  */
  149.  
  150. void     PMAPI PM_installAltBreakHandler(PM_breakHandler bh);
  151.  
  152. /* Routines to install and remove the critical error handler. The interrupt
  153.  * is handled by the PM/Pro library, and the operation will always be failed.
  154.  * You can check the status of the critical error handler with the
  155.  * appropriate function. If you pass the value TRUE for 'clearFlag', the
  156.  * internal flag will be reset ready to catch another critical error.
  157.  */
  158.  
  159. void     PMAPI PM_installCriticalHandler(void);
  160. int     PMAPI PM_criticalError(int *axValue, int *diValue, int clearFlag);
  161. void     PMAPI PM_restoreCriticalHandler(void);
  162.  
  163. /* Routine to install an alternate critical handler that will call your
  164.  * code directly. This is not available under all DOS extenders, but does
  165.  * work under real mode, DOS4GW and X32-VM. It does not work under the
  166.  * PowerPack 32 bit DOS extenders. If you figure out how to do it let us know!
  167.  *
  168.  * Note that you should either install one or the other, but not both!
  169.  */
  170.  
  171. void     PMAPI PM_installAltCriticalHandler(PM_criticalHandler);
  172.  
  173. /* Routine to lock and unlock regions of memory under a virtual memory
  174.  * environment. These routines _must_ be used to lock all hardware
  175.  * and mouse interrupt handlers installed, _AND_ any global data that
  176.  * these handler manipulate, so that they will always be present in memory
  177.  * to handle the incoming interrupts.
  178.  *
  179.  * Note that it is important to call the correct routine depending on
  180.  * whether the area being locked is code or data, so that under 32 bit
  181.  * PM we will get the selector value correct.
  182.  */
  183.  
  184. typedef void (*__codePtr)();
  185.  
  186. int     PMAPI PM_lockDataPages(void *p,uint len);
  187. int     PMAPI PM_unlockDataPages(void *p,uint len);
  188. int     PMAPI PM_lockCodePages(__codePtr p,uint len);
  189. int     PMAPI PM_unlockCodePages(__codePtr p,uint len);
  190.  
  191. /* Functions to manage protected mode only interrupt handlers */
  192.  
  193. void     PMAPI PM_getPMvect(int intno, PMFARPTR *isr);
  194. void     PMAPI PM_setPMvect(int intno, PM_intHandler ih);
  195. void     PMAPI PM_restorePMvect(int intno, PMFARPTR isr);
  196.  
  197. /* Functions to install and remove the virtual linear framebuffer
  198.  * emulation code. For unsupported DOS extenders and when running under
  199.  * a DPMI host like Windows or OS/2, this function will return a NULL.
  200.  */
  201.  
  202. bool     PMAPI VF_available(void);
  203. void *     PMAPI VF_init(ulong baseAddr,int bankSize,int codeLen,void *bankFunc);
  204. void     PMAPI VF_exit(void);
  205.  
  206. #ifdef    __cplusplus
  207. }                        /* End of "C" linkage for C++    */
  208. #endif
  209.  
  210. #endif /* __PMPRO_H */
  211.